fix(preprocessor): enforce Zend enum declaration rules - #61

…sions

Two gaps against Zend 8.4 in the enum declaration rules:

- The forbidden-magic-method check only ran in prepareClassMethod(), so a
  magic method arriving through a trait — either declared there or created
  by an alias adaptation that renames an ordinary method to a magic name —
  was silently accepted. Zend applies the ban to every method installed in
  the enum ("Enum Suit cannot include magic method __construct", probed on
  8.4.13 for both the composed and the aliased form). The check is now
  centralized in assertEnumMayIncludeMethod() and also invoked from
  installComposedTraitMethod(), which sees post-adaptation names.

- A backed case value beyond a scalar literal (case Two = 1 + 1, or a
  constant reference) read the nonexistent ->value off the expression node,
  warning "Undefined property" and recording null, which later made the
  constant folder resolve Number::Two to the case-name string. Zend accepts
  any constant expression here. The preprocessor now keeps the expression
  AST (the symbol environment is incomplete during prepare) in a ClassDef
  case-name => Expr map, and the convert phase evaluates it lazily with the
  existing constant-expression machinery in ClassConstantValueTrait,
  memoizing the result on first access. Plain constant fetches now also
  resolve program constants recorded by parseConstDef(), so
  `const TWO = 2; ... case Two = TWO;` folds to 2.

…oreign contexts

Two constant-expression paths in the lazy backed-case evaluation were
still incorrect:

- No in-progress guard: a self-referencing case such as
  `enum E: int { case A = E::A; }` re-entered getClassConstValue()
  through the stored expression AST until the stack was exhausted, and
  mutual cycles (`case A = E::B; case B = E::A;`) did the same. The
  evaluation now marks the case in progress for its duration
  (mirroring CONST_RECURSIVE on a Zend class-constant fetch, with
  gen_stub's case-table evaluation playing Zend's unmarked outer
  access) and fails when a marked case is fetched again, reporting the
  same constant Zend names on 8.4.13: `E::A` for the self-cycle and
  `E::B` for the mutual cycle. The AST entry now survives until
  evaluation succeeds, so an aborted evaluation cannot leave a
  half-initialized null behind in enumCases.

- Wrong resolution context: the first fetch of a case may happen while
  the translator is converting a different file (a constant initializer
  in namespace B referencing A\E::X), and names inside the stored
  expression were resolved against that context: the ClassConstFetch
  callback reduced the name node to a bare string, which
  getClassConstValue() then prefixed with the active namespace. The
  callback now prefers the NameResolver's resolvedName attribute (or
  the node's own fully qualified form), and the evaluation runs inside
  the enum's declaration context — its namespace plus the declaring
  file's use tables, captured at prepare like the trait ones — through
  withDeclarationNameContext(), factored out of withTraitNameContext()
  which needed the identical swap.

gen_stub's processStubFile() wrapped every exception into a bare
RuntimeException; TestError now passes through so compile diagnostics
raised during stub generation keep their type for the test harness.

Tests cover the self-cycle and mutual-cycle fatals (messages probed on
Zend 8.4.13), a cross-namespace program with a decoy B\Helper constant,
and a cross-file pair converted referencing-file-first, asserting the
zvals emitted into the stub registration (values verified against Zend
8.4.13).

…base

Since the enum-case class-constant work merged, `const REF = \A\E::X`
registers the case object as a persistent enum-case AST — matching Zend,
where var_dump(\B\Holder::REF) prints enum(A\E::X) — instead of folding
to the backing scalar. The cross-context tests now assert that
registration; the enum's own backed value stays a ZVAL_LONG.

Two compatibility gaps against Zend 8.4 in backed enum case values:

- A case value fetching another case's property
  (`case Two = E::One->value + 1;`) failed at stub registration: the
  independent constant-expression evaluator in gen_stub.php rejects
  Expr_PropertyFetch. The constant-expression machinery in
  ClassConstantValueTrait now evaluates `Case->value` / `Case->name`
  (PHP 8.2 "fetch properties in const expressions": the object must
  itself be a constant expression evaluating to an enum case; property
  names stay case-sensitive), and EnumCaseInfo::getDeclaration()
  consumes the value resolved there for any non-literal case value
  instead of re-evaluating the AST independently, so one evaluator owns
  cycle detection and declaration-context name resolution. The
  registration entry resolves through the unguarded evaluation, keeping
  Zend's cycle reporting: the mutual cycle still names E::B, and a true
  cycle through a property fetch (`case A = G::A->value + 1;`) fails
  with "Cannot declare self-referencing constant G::A" (probed on
  8.4.13).

- The cycle-detection key lowercased the whole "Enum::Case" string, but
  only enum class names are case-insensitive: `case A` and `case a` are
  distinct cases, and resolving a constant that walks both at once
  (`const REF = F::A;` with `case A = F::a->value - 1; case a = 2 + 1;`)
  reported a false "self-referencing constant F::a". The key now
  lowercases only the enum name.

Tests cover a property-fetch backed value (int arithmetic on ->value and
string concatenation on ->name), distinct A/a cases with a dependency
between their values held in the in-progress guard simultaneously, and
the self-cycle through ->value; all fixtures verified against Zend
8.4.13.